package xadrez;



import javax.swing.JOptionPane;
import java.awt.*;


public class Peca {
    
    private char tipo;
    private String cor;
    private int movimentos;    
    private int x;
    private int y;

    Peca ( char T, int x, int y, String color){
        this.tipo = T;
        String s = Character.toString(T);
        this.cor = color;
        this.movimentos = 0;     
        this.x = x;
        this.y = y;
       
    }
    
    
    public boolean[][] PossiveisMovimentos (Peca xadrez[][],int x, int j){
        boolean matriz[][] = new boolean [8][8];
        switch (tipo){
            case 'p':
                if(cor.equals("branco")){
                    matriz = CalculaMovPeaoBranco(xadrez,x,j);
                }
                else{
                    matriz = CalculaMovPeaoPreto(xadrez,x,j);
                }
                break;
            case 't':
                matriz = CalculaMovTorre(xadrez,x,j);
                break;
            case 'c':
                matriz = CalculaMovCavalo(xadrez,x,j);
                break;
            case 'b':
                matriz = CalculaMovBispo(xadrez,x,j);
                break;
            case 'k':
                matriz = CalculaMovRei(xadrez,x,j);
                break;
            case 'q':
                matriz = CalculaMovRainha(xadrez,x,j);
                break;
            case 'x':
                JOptionPane.showMessageDialog(null, "ERRO! PEÇA X NÃO PODERIA SER JOGADA!");
               break;
            default:
                JOptionPane.showMessageDialog(null, "ERRO! DEFAULT DA MOVIMENTAÇÃO DE PEÇA");
                break;
        }
        return matriz;
    }
    
    private boolean[][] CalculaMovPeaoBranco(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        if (y==6){
            if (xadrez[x][y-1].GetTipo() == 'x'){
                if (xadrez[x][y-2].GetTipo() == 'x'){
                    matriz[x][y-2] = true;
                }
            }
        }
        if((y-1) >=0 ){
            if (xadrez[x][y-1].GetTipo() == 'x'){
                matriz[x][y-1] = true;
            }
            if((x-1) >= 0){
                if (!(xadrez[x-1][y-1].GetTipo() == 'x')){ 
                    if(!xadrez[x-1][y-1].GetCor().equals(cor)){
                        matriz[x-1][y-1] = true;
                    }
                }
            }
            if((x+1) <= 7){
                if (!(xadrez[x+1][y-1].GetTipo() == 'x')){ 
                    if(!xadrez[x+1][y-1].GetCor().equals(cor)){
                        matriz[x+1][y-1] = true;
                    }
                }
            }
        }

        return matriz;
    }

    private boolean[][] CalculaMovPeaoPreto(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        if (y==1){
            if (xadrez[x][y+1].GetTipo() == 'x'){
                if (xadrez[x][y+2].GetTipo() == 'x'){
                    matriz[x][y+2] = true;
                }
            }
        }
        if((y+1) <=7){
            if (xadrez[x][y+1].GetTipo() == 'x'){
                matriz[x][y+1] = true;
            }
            if((x-1) >= 0){
                if (!(xadrez[x-1][y+1].GetTipo() == 'x')){ 
                    if(!xadrez[x-1][y+1].GetCor().equals(cor)){
                        matriz[x-1][y+1] = true;
                    }
                }
            }
            if((x+1) <= 7){
                if (!(xadrez[x+1][y+1].GetTipo() == 'x')){ 
                    if(!xadrez[x+1][y+1].GetCor().equals(cor)){
                        matriz[x+1][y+1] = true;
                    }
                }
            }
        }
        return matriz;
    }

    private boolean[][] CalculaMovTorre(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        boolean obstaculo = false;
        int i = 1;

        // reto - baixo
        while(((x+i) < 8) && (!obstaculo)){
            if (xadrez[x+i][y].GetCor().equals("null")){
                matriz[x+i][y] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y].GetCor().equals(cor)){
                    matriz[x+i][y] = true;
                }
            }
            i++;
        }

        // reto - cima
        obstaculo = false;
        i = 1;
        while(((x-i) >= 0) && (!obstaculo)){
            if (xadrez[x-i][y].GetCor().equals("null")){
                matriz[x-i][y] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y].GetCor().equals(cor)){
                    matriz[x-i][y] = true;
                }
            }
            i++;
        }

        // reto - esquerda
        obstaculo = false;
        i = 1;
        while(((y+i) < 8) && (!obstaculo)){
            if (xadrez[x][y+i].GetCor().equals("null")){
                matriz[x][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x][y+i].GetCor().equals(cor)){
                    matriz[x][y+i] = true;
                }
            }
            i++;
        }

        // reto - direita
        obstaculo = false;
        i = 1;
        while(((y-i) >= 0) && (!obstaculo)){
            if (xadrez[x][y-i].GetCor().equals("null")){
                matriz[x][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x][y-i].GetCor().equals(cor)){
                    matriz[x][y-i] = true;
                }
            }
            i++;
        }
        return matriz;   
    }
    
    
    private boolean[][] CalculaMovBispo(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        boolean obstaculo = false;
        int i = 1;
        int j = 1;

        // diagonal - direita - baixo
        while((((x+i) < 8) && ((y+i) < 8)) && (!obstaculo)){
            if (xadrez[x+i][y+i].GetCor().equals("null")){
                matriz[x+i][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y+i].GetCor().equals(cor)){
                    matriz[x+i][y+i] = true;
                }
            }
            i++;
            j++;
        }

        // diagonal - esquerda - baixo
        obstaculo = false;
        i = 1;
        while((((x-i) >= 0) && ((y+i) < 8)) && (!obstaculo)){
            if (xadrez[x-i][y+i].GetCor().equals("null")){
                matriz[x-i][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y+i].GetCor().equals(cor)){
                    matriz[x-i][y+i] = true;
                }
            }
            i++;
        }

        // diagonal - direita - cima
        obstaculo = false;
        i = 1;
        while((((x+i) < 8) && ((y-i) >= 0)) && (!obstaculo)){
            if (xadrez[x+i][y-i].GetCor().equals("null")){
                matriz[x+i][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y-i].GetCor().equals(cor)){
                    matriz[x+i][y-i] = true;
                }
            }
            i++;
            j++;
        }

        // diagonal - esquerda - cima
        obstaculo = false;
        i = 1;
        while((((x-i) >= 0) && ((y-i) >= 0)) && (!obstaculo)){
            if (xadrez[x-i][y-i].GetCor().equals("null")){
                matriz[x-i][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y-i].GetCor().equals(cor)){
                    matriz[x-i][y-i] = true;
                }
            }
            i++;
        }
        //MostraPossiveisMovimentos(matriz,x,y);
        return matriz;   
    }
    
     private boolean[][] CalculaMovRainha(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        boolean obstaculo = false;
        int i = 1;

        // diagonal - direita - baixo
        while((((x+i) < 8) && ((y+i) < 8)) && (!obstaculo)){
            if (xadrez[x+i][y+i].GetCor().equals("null")){
                matriz[x+i][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y+i].GetCor().equals(cor)){
                    matriz[x+i][y+i] = true;
                }
            }
            i++;
        }

        // diagonal - esquerda - baixo
        obstaculo = false;
        i = 1;
        while((((x-i) >= 0) && ((y+i) < 8)) && (!obstaculo)){
            if (xadrez[x-i][y+i].GetCor().equals("null")){
                matriz[x-i][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y+i].GetCor().equals(cor)){
                    matriz[x-i][y+i] = true;
                }
            }
            i++;
        }

        // diagonal - direita - cima
        obstaculo = false;
        i = 1;
        while((((x+i) < 8) && ((y-i) >= 0)) && (!obstaculo)){
            if (xadrez[x+i][y-i].GetCor().equals("null")){
                matriz[x+i][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y-i].GetCor().equals(cor)){
                    matriz[x+i][y-i] = true;
                }
            }
            i++;
        }

        // diagonal - esquerda - cima
        obstaculo = false;
        i = 1;
        while((((x-i) >= 0) && ((y-i) >= 0)) && (!obstaculo)){
            if (xadrez[x-i][y-i].GetCor().equals("null")){
                matriz[x-i][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y-i].GetCor().equals(cor)){
                    matriz[x-i][y-i] = true;
                }
            }
            i++;
        }

        // reto - direita
        obstaculo = false;
        i = 1;
        while(((x+i) < 8) && (!obstaculo)){
            if (xadrez[x+i][y].GetCor().equals("null")){
                matriz[x+i][y] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x+i][y].GetCor().equals(cor)){
                    matriz[x+i][y] = true;
                }
            }
            i++;
        }

        // reto - esquerda
        obstaculo = false;
        i = 1;
        while(((x-i) >= 0) && (!obstaculo)){
            if (xadrez[x-i][y].GetCor().equals("null")){
                matriz[x-i][y] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x-i][y].GetCor().equals(cor)){
                    matriz[x-i][y] = true;
                }
            }
            i++;
        }

        // reto - baixo
        obstaculo = false;
        i = 1;
        while(((y+i) < 8) && (!obstaculo)){
            if (xadrez[x][y+i].GetCor().equals("null")){
                matriz[x][y+i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x][y+i].GetCor().equals(cor)){
                    matriz[x][y+i] = true;
                }
            }
            i++;
        }

        // reto - cima
        obstaculo = false;
        i = 1;
        while(((y-i) >= 0) && (!obstaculo)){
            if (xadrez[x][y-i].GetCor().equals("null")){
                matriz[x][y-i] = true;
            }
            else{
                obstaculo = true;
                if (!xadrez[x][y-i].GetCor().equals(cor)){
                    matriz[x][y-i] = true;
                }
            }
            i++;
        }
        //MostraPossiveisMovimentos(matriz,x,y);
        return matriz;   
    }
    
    private boolean[][] CalculaMovCavalo(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        if ((x+2)<8){
            if((y+1)<8){
                if(!xadrez[x+2][y+1].GetCor().equals(cor)){
                    matriz[x+2][y+1] = true;
                }
            }
            if((y-1)>=0){
                if(!xadrez[x+2][y-1].GetCor().equals(cor)){
                    matriz[x+2][y-1] = true;
                }
            }
        }
        if ((x-2)>=0){
            if((y+1)<8){
                if(!xadrez[x-2][y+1].GetCor().equals(cor)){
                    matriz[x-2][y+1] = true;
                }
            }
            if((y-1)>=0){
                if(!xadrez[x-2][y-1].GetCor().equals(cor)){
                    matriz[x-2][y-1] = true;
                }
            }
        }
        if ((y+2)<8){
            if((x+1)<8){
                if(!xadrez[x+1][y+2].GetCor().equals(cor)){
                    matriz[x+1][y+2] = true;
                }
            }
            if((x-1)>=0){
                if(!xadrez[x-1][y+2].GetCor().equals(cor)){
                    matriz[x-1][y+2] = true;
                }
            }
            
        }
        if ((y-2)>=0){
            if((x+1)<8){
                if(!xadrez[x+1][y-2].GetCor().equals(cor)){
                    matriz[x+1][y-2] = true;
                }
            }
            if((x-1)>=0){
                if(!xadrez[x-1][y-2].GetCor().equals(cor)){
                    matriz[x-1][y-2] = true;
                }
            }
        }
        //MostraPossiveisMovimentos(matriz,x,y);
        return matriz;
    }    

    //FALTA: VERIFICA SE A CASA QUE ELE VAI ANDAR É AMEAÇADA
    private boolean[][] CalculaMovRei(Peca xadrez[][], int x, int y){
        boolean matriz[][] = new boolean [8][8];
        for (int i=(x-1); i<=(x+1); i++){
            for(int j=(y-1); j<=(y+1); j++){
                if((0<=i) & (i<=7)){
                    if((0<=j) & (j<=7)){
                        if (!xadrez[i][j].GetCor().equals(cor)){
                            matriz[i][j] = true;
                        }
                    }
                }
            }
        }
        return matriz;
    }
    
    private void MostraPossiveisMovimentos(boolean matriz[][], int a, int b){
        System.out.println();
        System.out.println();
        System.out.println("Tabuleiro de movimentos possiveis:");
        System.out.println("Tipo: " + this.tipo  + "  Cor: " + this.cor);
        System.out.println("X:" + a + "  Y:" + b);
        System.out.println();
        for (int x=0; x<8; x++){
            for (int y=0; y<8; y++){
                System.out.print(matriz[y][x]);
                System.out.print(" | ");
            }
            System.out.println();
        }
        System.out.println();
    }
    
    public String GetCor (){
        return cor;
    }

    public char GetTipo (){
        return tipo;
    }
    
    public int getX() { 
    	return x;
    }
    
    public int getY() {
    	return y;
    }

    public void SetTipoCor (char A, String B){
        this.tipo = A;
        this.cor = B;
    }

    public int GetMovimentos (){
        return this.movimentos;
    }

    public void SetMovimentos (int x){
        this.movimentos = x;
    }

     public void UpMovimentos (){
        this.movimentos++;
    }

}
